package main

import (
	"fmt"
	"strconv"
)

// 用于表示一组脉冲信号的配置或状态。每个字段（one, two, twop, four）可以用来存储不同类型或级别的脉冲信号的相关信息
type pulseset struct {
    one   int // 第一种脉冲信号的值或状态
    two   int // 第二种脉冲信号的值或状态
    twop  int // 可能是第二种脉冲信号的一个变种或相关值
    four  int // 第四种脉冲信号的值或状态
}

// multin 和 multout 数组，各包含24个脉冲通道，用于多路输入和输出脉冲信号
var multin, multout [24]chan pulse

// R 和 D 数组，各包含5个脉冲通道，用于特定类型的脉冲信号传输
var R, D [5]chan pulse

// A, S, AS, AC, SC, ASC, RS, DS, F 是单个脉冲通道，用于不同功能或模块之间的通信
var A, S, AS, AC, SC, ASC, RS, DS, F chan pulse

// lhppI, lhppII, rhppI, rhppII 是单个脉冲通道，可能用于左半部分和右半部分的脉冲处理
var lhppI, lhppII, rhppI, rhppII chan pulse

// stage 用于表示当前系统的状态或阶段
var stage int

// multff 数组，包含24个布尔值，用于标记与 multout 相关的状态或标志位
var multff [24]bool

// iersw, iercl, icandsw, icandcl, sigsw, placsw, prodsw 数组，各包含24个整数值，用于控制或记录状态变化
var iersw, iercl, icandsw, icandcl, sigsw, placsw, prodsw [24]int

// reset1ff 和 reset3ff 是布尔值，用于标记系统是否处于某种复位状态
var reset1ff, reset3ff bool

// Multl 和 Multr 是布尔值，可能用于标记左侧和右侧的操作状态
var Multl, Multr bool

// buffer61 和 f44 是布尔值，可能用于标记缓冲区或特定条件的状态
var buffer61, f44 bool

// multupdate 是一个通道，用于通知系统状态的变化或更新
var multupdate chan int

// 定义一个 10x10 的二维数组 table10，类型为 pulseset
var table10 [10][10]pulseset = [10][10]pulseset{
    // 第一行（索引 0）：全部为空
    {},
    
    // 第二行（索引 1）：全部为空
    {},
    
    // 第三行（索引 2）：从第6个元素开始有数据
    {{}, {}, {}, {}, {},
      {1, 0, 0, 0}, {1, 0, 0, 0}, {1, 0, 0, 0}, {1, 0, 0, 0}, {1, 0, 0, 0}},
      
    // 第四行（索引 3）：从第5个元素开始有数据
    {{}, {}, {}, {}, {1, 0, 0, 0},
      {1, 0, 0, 0}, {1, 0, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}},
      
    // 第五行（索引 4）：从第4个元素开始有数据
    {{}, {}, {}, {1, 0, 0, 0}, {1, 0, 0, 0},
      {0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}, {1, 1, 0, 0}, {1, 1, 0, 0}},
      
    // 第六行（索引 5）：从第3个元素开始有数据
    {{}, {}, {1, 0, 0, 0}, {1, 0, 0, 0}, {0, 1, 0, 0},
      {0, 1, 0, 0}, {1, 1, 0, 0}, {1, 1, 0, 0}, {0, 1, 1, 0}, {0, 1, 1, 0}},
      
    // 第七行（索引 6）：从第3个元素开始有数据
    {{}, {}, {1, 0, 0, 0}, {1, 0, 0, 0}, {0, 1, 0, 0},
      {1, 1, 0, 0}, {1, 1, 0, 0}, {0, 1, 1, 0}, {0, 1, 1, 0}, {1, 1, 1, 0}},
      
    // 第八行（索引 7）：从第3个元素开始有数据
    {{}, {}, {1, 0, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0},
      {1, 1, 0, 0}, {0, 0, 0, 1}, {0, 0, 0, 1}, {1, 0, 0, 1}, {0, 1, 0, 1}},
      
    // 第九行（索引 8）：从第3个元素开始有数据
    {{}, {}, {1, 0, 0, 0}, {0, 1, 0, 0}, {1, 1, 0, 0},
      {0, 0, 0, 1}, {0, 0, 0, 1}, {1, 0, 0, 1}, {0, 1, 0, 1}, {1, 1, 0, 1}},
      
    // 第十行（索引 9）：从第3个元素开始有数据
    {{}, {}, {1, 0, 0, 0}, {0, 1, 0, 0}, {1, 0, 1, 0},
      {0, 0, 0, 1}, {1, 1, 1, 0}, {0, 1, 0, 1}, {1, 0, 1, 1}, {0, 1, 1, 1}},
}

// 定义一个 10x10 的二维数组 table1，类型为 pulseset
var table1 [10][10]pulseset = [10][10]pulseset{
    // 第一行（索引 0）：全部为空
    {},
    
    // 第二行（索引 1）：从第二个元素开始有数据
    {{}, {1, 0, 0, 0}, {0, 1, 0, 0}, {1, 0, 1, 0}, {0, 1, 1, 0},
      {1, 0, 0, 1}, {0, 1, 0, 1}, {1, 0, 1, 1}, {0, 1, 1, 1}, {1, 1, 1, 1}},
      
    // 第三行（索引 2）：从第二个元素开始有数据
    {{}, {0, 1, 0, 0}, {0, 0, 0, 1}, {0, 0, 1, 1}, {0, 1, 1, 1},
      {}, {0, 1, 0, 0}, {0, 1, 1, 0}, {0, 0, 1, 1}, {0, 1, 1, 1}},
      
    // 第四行（索引 3）：从第二个元素开始有数据
    {{}, {1, 1, 0, 0}, {0, 0, 1, 1}, {1, 1, 1, 1}, {0, 1, 0, 0},
      {1, 1, 1, 0}, {0, 1, 1, 1}, {1, 0, 0, 0}, {0, 0, 0, 1}, {1, 0, 1, 1}},
      
    // 第五行（索引 4）：从第二个元素开始有数据
    {{}, {0, 1, 1, 0}, {0, 1, 1, 1}, {0, 1, 0, 0}, {0, 0, 1, 1},
      {}, {0, 1, 1, 0}, {0, 1, 1, 1}, {0, 1, 0, 0}, {0, 0, 1, 1}},
      
    // 第六行（索引 5）：从第二个元素开始有数据
    {{}, {1, 0, 0, 1}, {}, {1, 0, 0, 1}, {},
      {1, 0, 0, 1}, {}, {1, 0, 0, 1}, {}, {1, 0, 0, 1}},
      
    // 第七行（索引 6）：从第二个元素开始有数据
    {{}, {0, 0, 1, 1}, {0, 1, 0, 0}, {0, 1, 1, 1}, {0, 1, 1, 0},
      {}, {0, 0, 1, 1}, {0, 1, 0, 0}, {0, 1, 1, 1}, {0, 0, 0, 1}},
      
    // 第八行（索引 7）：从第二个元素开始有数据
    {{}, {1, 0, 1, 1}, {0, 1, 1, 0}, {1, 0, 0, 0}, {0, 1, 1, 1},
      {1, 1, 1, 0}, {0, 1, 0, 0}, {1, 1, 1, 1}, {0, 0, 1, 1}, {1, 1, 0, 0}},
      
    // 第九行（索引 8）：从第二个元素开始有数据
    {{}, {0, 1, 1, 1}, {0, 0, 1, 1}, {0, 1, 1, 0}, {0, 1, 0, 0},
      {}, {0, 1, 1, 1}, {0, 0, 1, 1}, {0, 0, 0, 1}, {0, 1, 0, 0}},
      
    // 第十行（索引 9）：从第二个元素开始有数据
    {{}, {1, 1, 1, 1}, {0, 1, 1, 1}, {1, 0, 1, 1}, {0, 1, 0, 1},
      {1, 0, 0, 1}, {0, 1, 1, 0}, {1, 0, 1, 0}, {0, 1, 0, 0}, {1, 0, 0, 0}},
}

// multstat 函数返回一个字符串，表示当前多路脉冲系统的状态。
func multstat() string {
    // 初始化状态字符串，首先添加当前 stage 的值
    s := fmt.Sprintf("%d ", stage)

    // 遍历 multff 数组，将每个布尔值转换为 "1" 或 "0" 并追加到状态字符串中
    for i, _ := range multff {
        if multff[i] {
            s += "1"
        } else {
            s += "0"
        }
    }

    // 根据 reset1ff 的值追加 "1" 或 "0"
    if reset1ff {
        s += " 1"
    } else {
        s += " 0"
    }

    // 根据 reset3ff 的值追加 "1" 或 "0"
    if reset3ff {
        s += " 1"
    } else {
        s += " 0"
    }

    return s // 返回最终的状态字符串
}

// multreset 函数重置多路脉冲系统的状态和通道。
func multreset() {
    // 重置 multin 和 multout 数组中的所有通道，并将 multff 数组中的所有布尔值设置为 false
    for i := 0; i < 24; i++ {
        multin[i] = nil
        multout[i] = nil
        multff[i] = false
        iersw[i] = 0
        iercl[i] = 0
        icandsw[i] = 0
        icandcl[i] = 0
        sigsw[i] = 0
        placsw[i] = 0
        prodsw[i] = 0
    }

    // 重置 R 和 D 数组中的所有通道
    for i := 0; i < 5; i++ {
        R[i] = nil
        D[i] = nil
    }

    // 重置其他单个通道
    A = nil
    S = nil
    AS = nil
    AC = nil
    SC = nil
    ASC = nil
    RS = nil
    DS = nil
    F = nil
    lhppI = nil
    lhppII = nil
    rhppI = nil
    rhppII = nil

    // 重置其他状态变量
    stage = 0
    reset1ff = false
    reset3ff = false
    Multl = false
    Multr = false
    buffer61 = false
    f44 = false

    // 发送更新信号
    multupdate <- 1
}

func multclear() {
}

// multplug 函数用于将指定的脉冲通道 ch 插入到系统中对应的插孔 jack。
func multplug(jack string, ch chan pulse) {
    // 使用 switch 语句根据 jack 的值将 ch 分配到相应的通道
    switch {
    case jack == "Rα", jack == "Ra", jack == "rα", jack == "ra":
        R[0] = ch
    case jack == "Rβ", jack == "Rb", jack == "rβ", jack == "rb":
        R[1] = ch
    case jack == "Rγ", jack == "Rg", jack == "rγ", jack == "rg":
        R[2] = ch
    case jack == "Rδ", jack == "Rd", jack == "rδ", jack == "rd":
        R[3] = ch
    case jack == "Rε", jack == "Re", jack == "rε", jack == "re":
        R[4] = ch
    case jack == "Dα", jack == "Da", jack == "dα", jack == "da":
        D[0] = ch
    case jack == "Dβ", jack == "Db", jack == "dβ", jack == "db":
        D[1] = ch
    case jack == "Dγ", jack == "Dg", jack == "dγ", jack == "dg":
        D[2] = ch
    case jack == "Dδ", jack == "Dd", jack == "dδ", jack == "dd":
        D[3] = ch
    case jack == "Dε", jack == "De", jack == "dε", jack == "de":
        D[4] = ch
    case jack == "A", jack == "a":
        A = ch
    case jack == "S", jack == "s":
        S = ch
    case jack == "AS", jack == "as":
        AS = ch
    case jack == "AC", jack == "ac":
        AC = ch
    case jack == "SC", jack == "sc":
        SC = ch
    case jack == "ASC", jack == "asc":
        ASC = ch
    case jack == "RS", jack == "rs":
        RS = ch
    case jack == "DS", jack == "ds":
        DS = ch
    case jack == "F", jack == "f":
        F = ch
    case jack == "LHPPI", jack == "lhppi", jack == "lhppI":
        lhppI = ch
    case jack == "LHPPII", jack == "lhppii", jack == "lhppII":
        lhppII = ch
    case jack == "RHPPI", jack == "rhppi", jack == "rhppI":
        rhppI = ch
    case jack == "RHPPII", jack == "rhppii", jack == "rhppII":
        rhppII = ch
    default:
        // 如果 jack 不匹配任何已知的插孔名称，则尝试解析为程序编号和方向（输入或输出）
        prog, err := strconv.Atoi(jack[:len(jack)-1])
        if err != nil {
            fmt.Printf("Invalid multiplier jack %s\n", jack)
            return
        }
        switch jack[len(jack)-1] {
        case 'i':
            multin[prog-1] = ch
        case 'o':
            multout[prog-1] = ch
        }
    }

    // 发送更新信号
    multupdate <- 1
}

// recv2val 函数将接收器名称转换为对应的整数值。
func recv2val(recv string) int {
    switch recv {
    case "α", "a", "alpha":
        return 0
    case "β", "b", "beta":
        return 1
    case "γ", "g", "gamma":
        return 2
    case "δ", "d", "delta":
        return 3
    case "ε", "e", "epsilon":
        return 4
    case "0":
        return 5
    }
    // 默认返回 5，表示无效或未知的接收器名称
    return 5
}

// multctl 函数处理控制指令，根据传入的 ctl 指令更新系统状态。
func multctl(ch chan [2]string) {
    // 定义产品名称数组，用于映射产品名称到索引
    products := [7]string{"A", "S", "AS", "0", "AC", "SC", "ASC"}

    for {
        // 从通道 ch 接收控制指令
        ctl := <-ch

        // 根据 ctl[0] 的前缀进行不同的操作
        switch {
        case len(ctl[0]) > 6 && ctl[0][:6] == "ieracc":
            prog, _ := strconv.Atoi(ctl[0][6:])
            iersw[prog-1] = recv2val(ctl[1])
        case len(ctl[0]) > 5 && ctl[0][:5] == "iercl":
            prog, _ := strconv.Atoi(ctl[0][5:])
            if ctl[1] == "C" {
                iercl[prog-1] = 1
            } else {
                iercl[prog-1] = 0
            }
        case len(ctl[0]) > 8 && ctl[0][:8] == "icandacc":
            prog, _ := strconv.Atoi(ctl[0][8:])
            icandsw[prog-1] = recv2val(ctl[1])
        case len(ctl[0]) > 7 && ctl[0][:7] == "icandcl":
            prog, _ := strconv.Atoi(ctl[0][7:])
            if ctl[1] == "C" {
                icandcl[prog-1] = 1
            } else {
                icandcl[prog-1] = 0
            }
        case len(ctl[0]) > 2 && ctl[0][:2] == "sf":
            prog, _ := strconv.Atoi(ctl[0][2:])
            val, _ := strconv.Atoi(ctl[1])
            if val == 0 {
                val = 1
            }
            sigsw[prog-1] = 10 - val
        case len(ctl[0]) > 5 && ctl[0][:5] == "place":
            prog, _ := strconv.Atoi(ctl[0][5:])
            val, _ := strconv.Atoi(ctl[1])
            placsw[prog-1] = val - 2
        case len(ctl[0]) > 4 && ctl[0][:4] == "prod":
            prog, _ := strconv.Atoi(ctl[0][4:])
            for i, p := range products {
                if p == ctl[1] {
                    prodsw[prog-1] = i
                    break
                }
            }
        default:
            fmt.Printf("Invalid multiplier switch %s\n", ctl[0])
        }
    }
}

// multargs 函数根据程序编号 prog 处理输入脉冲并设置标志位。
func multargs(prog int) {
    resp1 := make(chan int)
    resp2 := make(chan int)

    // 获取当前程序的 ier 和 icand 值
    ier := iersw[prog]
    icand := icandsw[prog]

    // 如果 ier 小于 5 且对应的 R 通道不为空，则发送脉冲
    if ier < 5 && R[ier] != nil {
        R[ier] <- pulse{1, resp1}
    }

    // 如果 icand 小于 5 且对应的 D 通道不为空，则发送脉冲
    if icand < 5 && D[icand] != nil {
        D[icand] <- pulse{1, resp2}
    }

    // 等待响应
    if ier < 5 && R[ier] != nil {
        <-resp1
    }

    if icand < 5 && D[icand] != nil {
        <-resp2
    }

    // 设置多路复用器标志位
    multff[prog] = true
    buffer61 = true
}

// shiftprod 函数根据 lhpp 和 rhpp 的值通过相应的通道发送脉冲，并等待响应。
func shiftprod(lhpp, rhpp int, resp1, resp2, resp3, resp4 chan int) {
    // 如果 lhppI 通道不为空且 lhpp 不为零，则发送脉冲
    if lhppI != nil && lhpp != 0 {
        lhppI <- pulse{lhpp >> uint(stage-2), resp1}
    }

    // 如果 lhppII 通道不为空且 lhpp 不为零，则发送脉冲
    if lhppII != nil && lhpp != 0 {
        lhppII <- pulse{(lhpp << uint(12-stage)) & 0x3ff, resp2}
    }

    // 如果 rhppI 通道不为空且 rhpp 不为零，则发送脉冲
    if rhppI != nil && rhpp != 0 {
        rhppI <- pulse{rhpp >> uint(stage-1), resp3}
    }

    // 如果 rhppII 通道不为空且 rhpp 不为零，则发送脉冲
    if rhppII != nil && rhpp != 0 {
        rhppII <- pulse{(rhpp << uint(11-stage)) & 0x3ff, resp4}
    }

    // 等待响应
    if lhppI != nil && lhpp != 0 {
        <-resp1
    }

    if lhppII != nil && lhpp != 0 {
        <-resp2
    }

    if rhppI != nil && rhpp != 0 {
        <-resp3
    }

    if rhppII != nil && rhpp != 0 {
        <-resp4
    }
}

// multunit 函数是处理多路脉冲系统的主函数，接收来自 cyctrunk 通道的脉冲并根据不同的条件执行相应操作。
func multunit(cyctrunk chan pulse) {
    // 定义用于存储状态字符串的变量
    var ier, icand string
    
    // 定义用于存储信号位图索引的变量
    var sigfig int

    // 初始化 multupdate 通道和响应通道
    multupdate = make(chan int)
    resp1 := make(chan int)
    resp2 := make(chan int)
    resp3 := make(chan int)
    resp4 := make(chan int)

    // 启动 multunit2 协程，假设 multunit2 是一个辅助函数，用于处理某些后台任务或并行操作
    go multunit2()

    // 进入无限循环，持续处理接收到的脉冲
    for {
        // 从 cyctrunk 通道接收脉冲 c
        // cyctrunk 是一个通道，用于传递脉冲数据结构，该结构包含 val 和 resp 字段
        c := <-cyctrunk

        // 根据脉冲的不同类型（通过 c.val 的不同值）执行相应的操作
        switch {
        case c.val&Cpp != 0:
            // 如果脉冲包含 Cpp 标志
            if f44 {
                // 如果 f44 标志为 true，则设置 stage 为 1 并重置 f44 标志
                stage = 1
                f44 = false
            } else if stage == 12 {
                // 如果当前阶段为 12，设置 reset1ff 和 reset3ff 标志，并发送握手信号
                reset1ff = true
                reset3ff = true
                handshake(1, F, resp1)
                stage++
            } else if stage == 13 {
                // 如果当前阶段为 13，查找 multff 中第一个为 true 的标志位
                which := -1
                for i, f := range multff {
                    if f {
                        which = i
                        break
                    }
                }
                if which != -1 {
                    // 发送握手信号并重置 multff 标志
                    handshake(1, multout[which], resp1)
                    multff[which] = false
                    // 根据 prodsw 的值发送不同的握手信号
                    switch prodsw[which] {
                    case 0:
                        handshake(1, A, resp1)
                    case 1:
                        handshake(1, S, resp1)
                    case 2:
                        handshake(1, AS, resp1)
                    case 4:
                        handshake(1, AC, resp1)
                    case 5:
                        handshake(1, SC, resp1)
                    case 6:
                        handshake(1, ASC, resp1)
                    }
                }
                // 重置 reset1ff 和 reset3ff 标志，并将 stage 设置为 0
                reset1ff = false
                reset3ff = false
                stage = 0
            } else if stage != 0 {
                // 查找最小的 placsw 值
                minplace := 10
                for i := 0; i < 24; i++ {
                    if multff[i] && placsw[i]+2 < minplace {
                        minplace = placsw[i] + 2
                    }
                }
                if stage == minplace+1 {
                    // 如果当前阶段等于最小 placsw 值加 1，发送握手信号并重置 Multl 和 Multr 标志
                    if ier[0] == 'M' {
                        handshake(1, DS, resp1)
                    }
                    if icand[0] == 'M' {
                        handshake(1, RS, resp1)
                    }
                    Multl = false
                    Multr = false
                    stage = 12
                } else {
                    // 否则增加 stage 值
                    stage++
                }
            }

        case c.val&Ccg != 0 && stage == 13:
            // 如果脉冲包含 Ccg 标志且 stage 为 13，查找 multff 中第一个为 true 的标志位
            which := -1
            for i, f := range multff {
                if f {
                    which = i
                    break
                }
            }
            // 根据 iercl 和 icandcl 标志清除累加器状态
            if iercl[which] == 1 {
                accclear(8)
            }
            if icandcl[which] == 1 {
                accclear(9)
            }

        case c.val&Onep != 0 && stage == 1:
            // 如果脉冲包含 Onep 标志且 stage 为 1，设置 Multl 和 Multr 标志，并计算 sigfig
            Multl = true
            Multr = true
            sigfig = -1
            for i := 0; i < 24; i++ {
                if multff[i] {
                    sigfig = sigsw[i]
                }
            }
            // 根据 sigfig 值发送握手信号
            if sigfig == 0 && lhppII != nil {
                handshake(1<<9, lhppII, resp1)
            } else if sigfig > 0 && sigfig < 9 && lhppI != nil {
                handshake(1<<uint(sigfig-1), lhppI, resp1)
            }

        case c.val&Fourp != 0 && stage == 1:
            // 类似于 Onep 处理，但仅在 stage 为 1 时处理
            if sigfig == 0 && lhppII != nil {
                handshake(1<<9, lhppII, resp1)
            } else if sigfig > 0 && sigfig < 9 && lhppI != nil {
                handshake(1<<uint(sigfig-1), lhppI, resp1)
            }

        case c.val&Onep != 0 && stage >= 2 && stage < 12:
            // 获取 ier 和 icand 状态，并根据这些状态生成 lhpp 和 rhpp 值
            ier = accstat(8)
            icand = accstat(9)
            lhpp := 0
            rhpp := 0
            for i := 0; i < 10; i++ {
                ps10 := table10[ier[stage]-'0'][icand[i+2]-'0']
                ps1 := table1[ier[stage]-'0'][icand[i+2]-'0']
                if ps10.one == 1 {
                    lhpp |= 1 << uint(9-i)
                }
                if ps1.one == 1 {
                    rhpp |= 1 << uint(9-i)
                }
            }
            // 调用 shiftprod 函数发送 lhpp 和 rhpp 值
            shiftprod(lhpp, rhpp, resp1, resp2, resp3, resp4)

        case c.val&Twop != 0 && stage >= 2 && stage < 12:
            // 类似于 Onep 处理，但使用 Twop 表中的值
            lhpp := 0
            rhpp := 0
            for i := 0; i < 10; i++ {
                ps10 := table10[ier[stage]-'0'][icand[i+2]-'0']
                ps1 := table1[ier[stage]-'0'][icand[i+2]-'0']
                if ps10.two == 1 {
                    lhpp |= 1 << uint(9-i)
                }
                if ps1.two == 1 {
                    rhpp |= 1 << uint(9-i)
                }
            }
            shiftprod(lhpp, rhpp, resp1, resp2, resp3, resp4)

        case c.val&Twopp != 0 && stage >= 2 && stage < 12:
            // 类似于 Onep 处理，但使用 Twopp 表中的值
            lhpp := 0
            rhpp := 0
            for i := 0; i < 10; i++ {
                ps10 := table10[ier[stage]-'0'][icand[i+2]-'0']
                ps1 := table1[ier[stage]-'0'][icand[i+2]-'0']
                if ps10.twop == 1 {
                    lhpp |= 1 << uint(9-i)
                }
                if ps1.twop == 1 {
                    rhpp |= 1 << uint(9-i)
                }
            }
            shiftprod(lhpp, rhpp, resp1, resp2, resp3, resp4)

        case c.val&Fourp != 0 && stage >= 2 && stage < 12:
            // 类似于 Onep 处理，但使用 Fourp 表中的值
            lhpp := 0
            rhpp := 0
            for i := 0; i < 10; i++ {
                ps10 := table10[ier[stage]-'0'][icand[i+2]-'0']
                ps1 := table1[ier[stage]-'0'][icand[i+2]-'0']
                if ps10.four == 1 {
                    lhpp |= 1 << uint(9-i)
                }
                if ps1.four == 1 {
                    rhpp |= 1 << uint(9-i)
                }
            }
            shiftprod(lhpp, rhpp, resp1, resp2, resp3, resp4)

        case c.val&Onepp != 0 && stage >= 2 && stage < 12:
            // 查找最小的 placsw 值，并在特定条件下发送握手信号
            minplace := 10
            for i := 0; i < 24; i++ {
                if multff[i] && placsw[i]+2 < minplace {
                    minplace = placsw[i] + 2
                }
            }
            if stage == minplace+1 && ier[0] == 'M' && icand[0] == 'M' {
                handshake(1<<10, rhppI, resp1)
            }

        case c.val&Rp != 0 && buffer61:
            // 如果脉冲包含 Rp 标志且 buffer61 标志为 true，重置 buffer61 并设置 f44 标志
            buffer61 = false
            f44 = true
        }

        // 如果脉冲包含响应通道，则向其发送确认信号
        if c.resp != nil {
            c.resp <- 1
        }
    }
}

// multunit2 是一个协程函数，负责监听来自多个通道的消息，并根据消息内容调用相应的处理函数。
func multunit2() {
    var p pulse // 定义一个脉冲变量 p

    for {
        p.resp = nil // 初始化 p 的响应通道为 nil

        // 使用 select 语句监听多个通道中的消息
        select {
        case <-multupdate:
            // 如果从 multupdate 通道接收到消息，则不做任何处理（空 case）
        
        case p = <-multin[0]:
            // 如果从 multin[0] 通道接收到消息，则调用 multargs(0) 处理该消息
            multargs(0)
        
        case p = <-multin[1]:
            // 如果从 multin[1] 通道接收到消息，则调用 multargs(1) 处理该消息
            multargs(1)
        
        case p = <-multin[2]:
            multargs(2)
        
        case p = <-multin[3]:
            multargs(3)
        
        case p = <-multin[4]:
            multargs(4)
        
        case p = <-multin[5]:
            multargs(5)
        
        case p = <-multin[6]:
            multargs(6)
        
        case p = <-multin[7]:
            multargs(7)
        
        case p = <-multin[8]:
            multargs(8)
        
        case p = <-multin[9]:
            multargs(9)
        
        case p = <-multin[10]:
            multargs(10)
        
        case p = <-multin[11]:
            multargs(11)
        
        case p = <-multin[12]:
            multargs(12)
        
        case p = <-multin[13]:
            multargs(13)
        
        case p = <-multin[14]:
            multargs(14)
        
        case p = <-multin[15]:
            multargs(15)
        
        case p = <-multin[16]:
            multargs(16)
        
        case p = <-multin[17]:
            multargs(17)
        
        case p = <-multin[18]:
            multargs(18)
        
        case p = <-multin[19]:
            multargs(19)
        
        case p = <-multin[20]:
            multargs(20)
        
        case p = <-multin[21]:
            multargs(21)
        
        case p = <-multin[22]:
            multargs(22)
        
        case p = <-multin[23]:
            multargs(23)
        }

        // 如果 p 中包含响应通道，则向该通道发送确认信号 1
        if p.resp != nil {
            p.resp <- 1
        }
    }
}
